/**
 * API调用工具函数
 */
const envConfig = require('../config/env.js');
const debugTools = require('./debugTools.js');

// 获取服务器基础URL，支持环境配置
function getBaseURL() {
  try {
    // 首先尝试从环境配置获取
    const config = envConfig.getConfig();
    if (config && config.serverUrl) {
      console.debug('[ENV] 使用环境配置的服务器URL:', config.serverUrl);
      return config.serverUrl;
    }
    
    // 如果环境配置不可用，回退到从app全局变量获取
    const app = getApp();
    return app && app.globalData && app.globalData.serverUrl ? 
      app.globalData.serverUrl : 'http://localhost:3000';
  } catch (e) {
    console.error('获取服务器URL出错:', e);
    return 'http://localhost:3000'; // 返回默认地址
  }
}

// 获取API基础URL
function getApiBaseURL() {
  try {
    // 首先尝试从环境配置获取
    const config = envConfig.getConfig();
    if (config && config.baseUrl) {
      console.debug('[ENV] 使用环境配置的API基础URL:', config.baseUrl);
      return config.baseUrl;
    }
    
    // 如果环境配置不可用，回退到从app全局变量获取
    const app = getApp();
    return app && app.globalData && app.globalData.baseUrl ? 
      app.globalData.baseUrl : 'http://localhost:3000/api';
  } catch (e) {
    console.error('获取API基础URL出错:', e);
    return 'http://localhost:3000/api'; // 返回默认地址
  }
}

// API端点集合
const apiEndpoints = {
  getApiBaseURL() {
    return app.globalData.apiUrl || 'http://localhost:3000/api';
  },
  
  // 获取本地API地址的函数，使用环境配置
  getLocalDiseaseInfoUrl: () => {
    const baseUrl = getApiBaseURL();
    return `${baseUrl}/disease/info`;
  },
  
  // AI诊断API地址，使用环境配置
  getAiDiagnosisUrl() {
    const baseUrl = getApiBaseURL();
    return `${baseUrl}/diagnosis/ai`;
  },
  
  // 豆包植物识别API地址
  identifyPlantWithDoubaoUrl() {
    const baseUrl = getApiBaseURL();
    return `${baseUrl}/diagnosis/identify-with-doubao`;
  },
  
  // 微信登录API地址
  wechatLoginUrl() {
    const baseUrl = getApiBaseURL();
    return `${baseUrl}/auth/wechat-login`;
  },
  
  // 保存诊断历史API地址
  saveDiagnosisHistoryUrl() {
    const baseUrl = getApiBaseURL();
    return `${baseUrl}/auth/save-diagnosis`;
  },
  
  // 获取诊断历史API地址
  getDiagnosisHistoryUrl() {
    const baseUrl = getApiBaseURL();
    return `${baseUrl}/auth/diagnosis-history`;
  },
  
  // 新增任务相关API
  startIdentifyTaskUrl() {
    const baseUrl = getApiBaseURL();
    return `${baseUrl}/diagnosis/start-identify-task`;
  },
  
  checkTaskResultUrl() {
    const baseUrl = getApiBaseURL();
    return `${baseUrl}/diagnosis/check-task-result`;
  },
  
  // 豆包植物识别API端点
  identifyWithDoubaoUrl: function() {
    return `${getBaseURL()}/api/diagnosis/identify-with-doubao`;
  },
  
  // AI诊断API端点
  aiDiagnosisUrl: function() {
    return `${getBaseURL()}/api/diagnosis/ai`;
  },
  
  // 保存诊断历史记录API端点
  saveDiagnosisHistoryUrl: function() {
    return `${getBaseURL()}/api/auth/save-diagnosis-history`;
  }
};

// 错误码映射
const errorCodeMap = {
  400: '请求参数错误',
  401: '授权验证失败',
  403: '调用次数超限或权限不足',
  500: '服务器内部错误'
};

/**
 * 处理API错误响应
 * @param {number} statusCode - HTTP状态码
 * @return {string} 错误信息
 */
function handleApiError(statusCode) {
  return errorCodeMap[statusCode] || `未知错误(${statusCode})`;
}

/**
 * 对Base64图片进行处理，确保可正确发送给API
 * @param {string} base64Data - Base64编码的图片数据
 * @return {string} 处理后的Base64字符串
 */
function formatBase64(base64Data) {
  // 如果已经包含前缀，则直接返回
  if (base64Data.indexOf('data:image/') !== -1) {
    return base64Data;
  }
  // 否则添加前缀
  return `data:image/jpeg;base64,${base64Data}`;
}

/**
 * 使用豆包识别植物
 * @param {string} base64Image - Base64编码的图片数据
 * @return {Promise} - 返回识别结果的Promise
 */
function identifyPlantWithDoubao(base64Image) {
  if (!base64Image) {
    return Promise.reject(new Error('图片数据不能为空'));
  }

  try {
    const apiUrl = apiEndpoints.identifyPlantWithDoubaoUrl();
    console.log(`调用豆包植物识别API: ${apiUrl}`);
    
    // 验证base64Image数据
    if (!base64Image || typeof base64Image !== 'string') {
      console.error('无效的图片数据:', typeof base64Image);
      return Promise.reject(new Error('图片数据无效，必须是Base64编码的字符串'));
    }
    
    let processedImage = base64Image;
    
    // 检查是否已包含前缀，如果没有，添加默认JPEG前缀
    if (!base64Image.startsWith('data:image/')) {
      processedImage = `data:image/jpeg;base64,${base64Image}`;
      console.log('已添加默认图片前缀: data:image/jpeg;base64,');
    } else {
      console.log('图片数据已包含前缀，无需添加');
    }
    
    // 记录图片数据类型和长度，帮助调试
    console.log(`处理后图片数据长度: ${processedImage.length}`);
    
    return new Promise((resolve, reject) => {
      const maxRetries = 3; // 最大重试次数
      let retryCount = 0;

      function makeRequest() {
        wx.request({
          url: apiUrl,
          method: 'POST',
          data: {
            imageBase64: processedImage
          },
          timeout: 15000, // 设置超时时间为15秒
          success: (res) => {
            console.log(`豆包植物识别API响应:`, res.data);
            
            // 检查是否为404错误（API不存在）
            if (res.statusCode === 404) {
              console.warn('豆包植物识别API不存在 (404)，需要实现服务端API');
              reject(new Error('API接口不存在 (404)'));
              return;
            }
            
            if (res.data && res.statusCode === 200) {
              resolve(res.data);
            } else {
              console.warn(`豆包植物识别API返回状态码 ${res.statusCode}:`, res.data);
              reject(new Error('豆包植物识别失败: ' + ((res.data && res.data.message) || '未知错误')));
            }
          },
          fail: (err) => {
            console.error(`豆包植物识别API请求失败:`, err);
            if (retryCount < maxRetries) {
              retryCount++;
              console.log(`请求失败，正在进行第${retryCount}次重试...`);
              makeRequest(); // 递归重试
            } else {
              reject(new Error('请求失败: ' + (err.errMsg || '网络错误')));
            }
          }
        });
      }

      makeRequest(); // 发起首次请求
    });
  } catch (e) {
    console.error('获取全局数据出错:', e);
    return Promise.reject(new Error('获取全局数据出错: ' + e.message));
  }
}

/**
 * 从服务器获取植物病害信息
 * @param {string} plantName - 植物名称
 * @return {Promise} - 返回病害信息的Promise
 */
function getPlantDiseases(plantName) {
  if (!plantName) {
    console.error('获取病害信息失败: 植物名称为空');
    return Promise.reject(new Error('植物名称不能为空'));
  }

  try {
    const apiUrl = apiEndpoints.getLocalDiseaseInfoUrl();
    console.log(`调用本地服务器API: ${apiUrl}, 参数: ${plantName}`);
      
    return new Promise((resolve, reject) => {
      wx.request({
        url: apiUrl,
        method: 'GET',
        data: {
          plantName: plantName
        },
        success: (res) => {
          console.log(`本地服务器API响应(${apiUrl}):`, res.data);
          if (res.statusCode === 200) {
            resolve(res.data);
          } else {
            console.warn(`本地服务器API返回状态码 ${res.statusCode}:`, res.data);
            reject(new Error('获取病害信息失败: ' + ((res.data && res.data.message) || '未知错误')));
          }
        },
        fail: (err) => {
          console.error(`本地服务器API请求失败(${apiUrl}):`, err);
          reject(new Error('请求失败: ' + (err.errMsg || '网络错误')));
        }
      });
    });
  } catch (e) {
    console.error('获取全局数据出错:', e);
    return Promise.reject(new Error('获取全局数据出错: ' + e.message));
  }
}

/**
 * 获取AI植物诊断和建议
 * @param {string} plantName - 植物名称
 * @param {string} base64Image - Base64编码的图片数据
 * @param {string} region - 地区信息（可选）
 * @param {string} season - 季节信息（可选）
 * @param {object} plantInfo - 阿里云识别结果的植物信息（可选）
 * @return {Promise} - 返回AI诊断结果的Promise
 */
function getAiDiagnosis(plantName, base64Image, region = '', season = '', plantInfo = null) {
  if (!plantName) {
    return Promise.reject(new Error('植物名称不能为空'));
  }

  try {
    const apiUrl = apiEndpoints.getAiDiagnosisUrl();
    console.log(`调用AI诊断API: ${apiUrl}, 植物: ${plantName}`);
    
    // 记录API请求信息
    const requestInfo = debugTools.showApiRequestInfo(apiUrl, {
      plantName,
      imageBase64: base64Image, // 这里的图片数据会被过滤掉，只保留长度信息
      region,
      season,
      plantInfo
    });
    console.log('发送API请求:', requestInfo);
    
    // 验证base64Image数据
    if (!base64Image || typeof base64Image !== 'string') {
      console.error('无效的图片数据:', typeof base64Image);
      return Promise.reject(new Error('图片数据无效，必须是Base64编码的字符串'));
    }
    
    // 确保base64Image具有正确的格式前缀
    let processedImage = base64Image;
    
    // 检查是否已包含前缀，如果没有，添加默认JPEG前缀
    if (!base64Image.startsWith('data:image/')) {
      processedImage = `data:image/jpeg;base64,${base64Image}`;
      console.log('已添加默认图片前缀: data:image/jpeg;base64,');
    } else {
      console.log('图片数据已包含前缀，无需添加');
    }
    
    // 记录图片数据类型和长度，帮助调试
    console.log(`处理后图片数据长度: ${processedImage.length}`);
      
    return new Promise((resolve, reject) => {
      wx.request({
        url: apiUrl,
        method: 'POST',
        data: {
          plantName: plantName,
          imageBase64: processedImage, // 发送处理后的图片数据
          region: region,
          season: season,
          plantInfo: plantInfo // 传递阿里云植物识别结果
        },
        success: (res) => {
          console.log(`AI诊断API响应:`, res.data);
          if (res.statusCode === 200) {
            resolve(res.data);
          } else {
            console.warn(`AI诊断API返回状态码 ${res.statusCode}:`, res.data);
            reject(new Error('获取AI诊断失败: ' + ((res.data && res.data.message) || '未知错误')));
          }
        },
        fail: (err) => {
          console.error(`AI诊断API请求失败:`, err);
          reject(new Error('请求失败: ' + (err.errMsg || '网络错误')));
        }
      });
    });
  } catch (e) {
    console.error('获取全局数据出错:', e);
    return Promise.reject(new Error('获取全局数据出错: ' + e.message));
  }
}

/**
 * 启动植物识别任务 - 支持长时间处理
 * @param {string} base64Image - Base64编码的图片数据
 * @returns {Promise} - 返回任务ID的Promise
 */
function startIdentifyTask(base64Image) {
  if (!base64Image) {
    return Promise.reject(new Error('图片数据不能为空'));
  }

  try {
    const apiUrl = apiEndpoints.startIdentifyTaskUrl();
    console.log(`启动植物识别任务: ${apiUrl}`);
    
    // 验证base64Image数据
    if (!base64Image || typeof base64Image !== 'string') {
      console.error('无效的图片数据:', typeof base64Image);
      return Promise.reject(new Error('图片数据无效，必须是Base64编码的字符串'));
    }
    
    let processedImage = base64Image;
    
    // 检查是否已包含前缀，如果没有，添加默认JPEG前缀
    if (!base64Image.startsWith('data:image/')) {
      processedImage = `data:image/jpeg;base64,${base64Image}`;
      console.log('已添加默认图片前缀: data:image/jpeg;base64,');
    } else {
      console.log('图片数据已包含前缀，无需添加');
    }
    
    return new Promise((resolve, reject) => {
      wx.request({
        url: apiUrl,
        method: 'POST',
        data: {
          imageBase64: processedImage
        },
        success: (res) => {
          console.log(`启动植物识别任务响应:`, res.data);
          
          // 检查是否为404错误（API不存在）
          if (res.statusCode === 404) {
            console.warn('植物识别任务API不存在 (404)，需要实现服务端API');
            reject(new Error('API接口不存在 (404)'));
            return;
          }
          
          if (res.data && res.statusCode === 200) {
            resolve(res.data);
          } else {
            console.warn(`启动植物识别任务返回状态码 ${res.statusCode}:`, res.data);
            reject(new Error('启动植物识别任务失败: ' + ((res.data && res.data.message) || '未知错误')));
          }
        },
        fail: (err) => {
          console.error(`启动植物识别任务请求失败:`, err);
          reject(new Error('请求失败: ' + (err.errMsg || '网络错误')));
        }
      });
    });
  } catch (e) {
    console.error('获取全局数据出错:', e);
    return Promise.reject(new Error('获取全局数据出错: ' + e.message));
  }
}

/**
 * 检查植物识别任务结果
 * @param {string} taskId - 任务ID
 * @returns {Promise} - 返回任务结果的Promise
 */
function checkTaskResult(taskId) {
  if (!taskId) {
    return Promise.reject(new Error('任务ID不能为空'));
  }

  try {
    const apiUrl = apiEndpoints.checkTaskResultUrl();
    console.log(`检查植物识别任务结果: ${apiUrl}, taskId: ${taskId}`);
    
    return new Promise((resolve, reject) => {
      wx.request({
        url: apiUrl,
        method: 'GET',
        data: { taskId },
        success: (res) => {
          console.log(`检查植物识别任务结果响应:`, res.data);
          if (res.data && res.statusCode === 200) {
            resolve(res.data);
          } else {
            console.warn(`检查植物识别任务结果返回状态码 ${res.statusCode}:`, res.data);
            reject(new Error('检查植物识别任务结果失败: ' + ((res.data && res.data.message) || '未知错误')));
          }
        },
        fail: (err) => {
          console.error(`检查植物识别任务结果请求失败:`, err);
          reject(new Error('请求失败: ' + (err.errMsg || '网络错误')));
        }
      });
    });
  } catch (e) {
    console.error('获取全局数据出错:', e);
    return Promise.reject(new Error('获取全局数据出错: ' + e.message));
  }
}

module.exports = {
  get localDiseaseInfo() {
    const baseUrl = getApiBaseURL();
    return `${baseUrl}/diagnosis/info`;
  },
  handleApiError,
  formatBase64,
  identifyPlantWithDoubao,
  getPlantDiseases,
  getAiDiagnosis,
  startIdentifyTask,
  checkTaskResult,
  apiEndpoints
};
